home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / amok_lha / amok24.lha / DME / SRC / source.zoo / refs.c < prev    next >
C/C++ Source or Header  |  1989-07-03  |  12KB  |  451 lines
  1.  
  2. /*
  3.  *  REFS.C
  4.  *
  5.  *  Bringup a cross reference editor window.  The file S:dme.refs and
  6.  *  dme.refs in the current directory are searched for the reference.
  7.  *  If found, the file specified is searched and the segment specified
  8.  *  loaded as a new file in a new window.
  9.  */
  10.  
  11. #include "defs.h"
  12. #include <stdio.h>
  13.  
  14. #define PEN    struct _PEN
  15.  
  16. extern PROC *proc;
  17.  
  18. PEN {
  19.     MNODE   Node;
  20.     char    *path;
  21. };
  22.  
  23. extern char *breakout();
  24.  
  25. MLIST   PBase;          /*  special DME paths   */
  26.  
  27. /*
  28.  *  Special DME paths for REF and CTAGS
  29.  */
  30.  
  31. #ifndef NO_DO2
  32.  
  33. void
  34. do_addpath()
  35. {
  36.     register PEN *pen;
  37.     register short len = strlen(av[1]);
  38.  
  39.     for (pen = (PEN *)PBase.mlh_Head; pen->Node.mln_Succ; pen = (PEN *)pen->Node.mln_Succ) {
  40.         if (strcmp(av[1], pen->path) == 0)
  41.             return;
  42.     }
  43.     if (pen = malloc(sizeof(PEN)+len+2)) {
  44.         pen->path = (char *)(pen + 1);
  45.         strcpy(pen->path, av[1]);
  46.         switch(pen->path[len-1]) {
  47.         case ':':
  48.         case '/':
  49.             break;
  50.         default:
  51.             strcat(pen->path, "/");
  52.         }
  53.     }
  54.     AddTail(&PBase, pen);
  55. }
  56.  
  57. do_rempath()
  58. {
  59.     register PEN *pen, *npen;
  60.  
  61.     for (pen = (PEN *)PBase.mlh_Head; npen = (PEN *)pen->Node.mln_Succ; pen = npen) {
  62.         if (wildcmp(av[1], pen->path)) {
  63.             Remove(pen);
  64.             free(pen);
  65.         }
  66.     }
  67. }
  68.  
  69. #endif
  70.  
  71. #ifndef NO_DO_CTAGS
  72.  
  73. /*
  74.  *  Implement ctags
  75.  */
  76.  
  77. void
  78. do_ctags()
  79. {
  80.     char str[64];
  81.     char path[128];
  82.     char buf[128];
  83.     char sbuf[128];
  84.     long xfi;
  85.     short xlen;
  86.     short slen;
  87.     short dbaselen;
  88.     long oldlock = CurrentDir(Ep->dirlock);
  89.     ED *ed;
  90.  
  91.     {
  92.         register short i, j;
  93.  
  94.         for (i = Ep->Column; Current[i] == ' '; ++i);
  95.         for (j = i; ; ++j) {
  96.             register short c = Current[j];
  97.             if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c == '_') || (c >= '0' && c <= '9'))
  98.                 continue;
  99.             break;
  100.         }
  101.         j -= i;
  102.         if (j > 63)
  103.             j = 63;
  104.         bmov(Current+i, str, j);
  105.         str[j] = 0;
  106.         xlen = j;
  107.     }
  108.     if (!Ep->iconmode)
  109.         title("search tags");
  110.     {
  111.         long xfi;
  112.         PEN *pen, *npen;
  113.         register long i;
  114.         register short j, len;
  115.  
  116.         dbaselen = dirpart(Ep->Name);
  117.         bmov(Ep->Name, path, dbaselen);
  118.         strcpy(path+dbaselen, "tags");
  119.  
  120.         /*
  121.          *  Note: pen not used first pass and set to list head, so next
  122.          *  pass it will be the first element.
  123.          *
  124.          *  Note2:  The file path depends on several factors.  (1) tags in
  125.          *          'current' directory, use path to name of current window.
  126.          *          (2) tags in directory in DME special path, use special
  127.          *          path.  (3) tag entry is a full path name, override
  128.          *          previous directories.
  129.          */
  130.  
  131.         for (pen = (PEN *)&PBase; npen = (PEN *)pen->Node.mln_Succ; pen = npen) {
  132.             mountrequest(0);
  133.             proc->pr_WindowPtr = (APTR)Ep->Win;
  134.             if (xfi = xfopen(path, "r", 4096)) {
  135.                 mountrequest(1);
  136.                 while ((len = xefgets(xfi, buf, 128)) >= 0) {
  137.                     for (j = 0; buf[j] && buf[j] != ' '; ++j);
  138.                     if (j == 0 || buf[0] == '#')
  139.                         continue;
  140.                     if (j == xlen && strncmp(str, buf, j) == 0) {
  141.                         while (buf[j] == ' ')
  142.                             ++j;
  143.                         /*
  144.                          *  Extract the file name into str.  If the
  145.                          *  filename does not contain an absolute path,
  146.                          *  prepend it with such.
  147.                          */
  148.                         {
  149.                             char prep = 1;
  150.                             for (i = 0; buf[j] && buf[j] != ' '; ++i, ++j) {
  151.                                 str[i] = buf[j];
  152.                                 if (str[i] == ':')
  153.                                     prep = 0;
  154.                             }
  155.                             if (prep) {
  156.                                 bmov(str, str + dbaselen, i);
  157.                                 bmov(path, str, dbaselen);
  158.                                 i += dbaselen;
  159.                             }
  160.                         }
  161.                         str[i] = 0;
  162.  
  163.                         while (buf[j] && buf[j] != '^')     /*  SEARCH ARG */
  164.                             ++j;
  165.                         xfclose(xfi);
  166.                         if (buf[j] != '^') {
  167.                             title("tags error");
  168.                             goto done;
  169.                         }
  170.                         ++j;
  171.                         strcpy(sbuf, buf+j);
  172.                         slen = strlen(sbuf);
  173.                         if ((ed = finded(str, 0)) == NULL) {
  174.                             strcpy(buf, "newwindow newfile ");
  175.                             strcat(buf, str);
  176.                             do_command(buf);
  177.                             ed = finded(str, 0);
  178.                         } else {
  179.                             WindowToFront(ed->Win);
  180.                             ActivateWindow(ed->Win);
  181.                         }
  182.                         if (ed == NULL) {
  183.                             title("unable to load file");
  184.                             goto done;
  185.                         }
  186.                         text_switch(ed->Win);
  187.                         if (Ep->iconmode)
  188.                             uniconify();
  189.                         else
  190.                             text_cursor(0);
  191.                         for (i = 0; i < ed->Lines; ++i) {
  192.                             if (strncmp(ed->List[i], sbuf, slen) == 0)
  193.                                 break;
  194.                         }
  195.                         sprintf(buf, "first goto %ld", i+1);
  196.                         do_command(buf);
  197.                         goto done;
  198.                     }
  199.                 }
  200.                 xfclose(xfi);
  201.             } else {
  202.                 mountrequest(1);
  203.             }
  204.             if (npen->Node.mln_Succ) {
  205.                 strcpy(path, npen->path);
  206.                 strcat(path, "tags");
  207.                 dbaselen = strlen(npen->path);
  208.             }
  209.         }
  210.         title("tag not found");
  211.     }
  212. done:
  213.     CurrentDir(oldlock);
  214. }
  215.  
  216. #endif
  217.  
  218. #ifndef NO_DO_REFS
  219.  
  220. /*
  221.  *  Implement references
  222.  */
  223.  
  224. int
  225. ref_cmp(str1,str2)
  226. char *str1;
  227. char *str2;
  228. {
  229.    register char *s1;
  230.    register char *s2;
  231.  
  232.    s1 = str1;
  233.    s2 = str2;
  234.  
  235.    while(is_ascii(*s1) && is_ascii(*s2) && (*s1 == *s2) ) {
  236.       s1++;
  237.       s2++;
  238.    }
  239.    if(!is_ascii(*s1) && !is_ascii(*s2))
  240.       return 0;
  241.    else
  242.       return 1;
  243. }
  244.  
  245. void
  246. do_refs()
  247. {
  248.     char str[256];
  249.     char path[128];
  250.     char *srch;
  251.     char *file;
  252.     char *estr;
  253.     long len;
  254.     int bcnt = 10;
  255.     register short i, j;
  256.     short slen,elen;
  257.     long xfi, xfj;
  258.     short tmph, tmpw;
  259.     long oldlock = CurrentDir(Ep->dirlock);
  260.  
  261.     i = Ep->Column;
  262.     while( !is_ascii(Current[i]) && (i > 0) )
  263.       i--;
  264.     while(  is_ascii(Current[i]) && (i > 0) )
  265.       i--;
  266.     if(!is_ascii(Current[i]))
  267.       i++;
  268.     j = i;
  269.     while(  is_ascii(Current[j]) && (j < 256) )
  270.       j++;
  271.     j -= i;
  272.     if (j > 63)
  273.         j = 63;
  274.     bmov(Current+i, str, j);
  275.     str[j] = 0;
  276.  
  277.     title("search .refs");
  278.     {
  279.         register PEN *pen;
  280.         register PEN *npen;
  281.  
  282.         strcpy(path, "dme.refs");
  283.         mountrequest(0);
  284.         for (pen = (PEN *)&PBase; npen = (PEN *)pen->Node.mln_Succ; pen = npen) {
  285.             if (searchref(path, str, &srch, &file, &len, &estr)) {
  286.                 mountrequest(1);
  287.                 goto found;
  288.             }
  289.             if (npen->Node.mln_Succ) {
  290.                 strcpy(path, npen->path);
  291.                 strcat(path, "dme.refs");
  292.             }
  293.         }
  294.         sprintf(path,"Reference for \'%s\' not found",str);
  295.         title(path);
  296.         mountrequest(1);
  297.         goto done;
  298.     }
  299. found:
  300.     title("search file");
  301.     slen = strlen(srch);
  302.     if (estr)
  303.     elen = strlen(estr);
  304.  
  305.     proc->pr_WindowPtr = (APTR)Ep->Win;
  306.     if (xfi = xfopen(file, "r", 4096)) {
  307.         short lenstr;
  308.         while ((lenstr = xefgets(xfi, str, 256)) >= 0) {
  309.             for(i=0;(i < 256) && (str[i] == 32);i++);
  310.             if (strncmp(&str[i], srch, slen) == 0) {
  311.                 title("load..");
  312.                 if (xfj = xfopen("t:dme_ref", "w", 1024)) {
  313.                     tmph = 0;
  314.                     tmpw = 0;
  315.                     do {
  316.                         if (lenstr > tmpw)
  317.                             tmpw = strlen(str);
  318.                         ++tmph;
  319.                         xfwrite(xfj, str, strlen(str));
  320.                         xfwrite(xfj, "\n", 1);
  321.                         for(j=0;(j < 256) && (str[j] == 32);j++);
  322.                         if (estr && strncmp(&str[j],estr,elen) == 0)
  323.                             break;
  324.                         --len;
  325.                     } while ((lenstr=xefgets(xfi, str, 256)) >= 0 && len);
  326.                     xfclose(xfj);
  327.                     if (tmph > 10)
  328.                         tmph = 10;
  329.                     if (tmpw > 80)
  330.                         tmpw = 80;
  331.                     sprintf(str, "tmpheight %ld tmpwidth %ld newwindow newfile t:dme_ref", (tmph<<3)+24, (tmpw<<3)+24);
  332.                     do_command(str);
  333.                     unlink("t:dme_ref");
  334.                 } else {
  335.                     title("Unable to open t:dme_ref for write");
  336.                 }
  337.                 xfclose(xfi);
  338.                 free(srch);
  339.                 free(file);
  340.                 if (estr)
  341.                     free(estr);
  342.                 goto done;
  343.             }
  344.             if (--bcnt == 0) {      /* check break every so so  */
  345.                 bcnt = 50;
  346.                 if (breakcheck())
  347.                     break;
  348.             }
  349.         }
  350.         xfclose(xfi);
  351.         title("Search failed");
  352.     } else {
  353.         title("Unable to open sub document");
  354.     }
  355.     free(srch);
  356.     free(file);
  357.     if (estr)
  358.         free(estr);
  359. done:
  360.     CurrentDir(oldlock);
  361. }
  362.  
  363. /*
  364.  *  Reference file format:
  365.  *
  366.  *  `key' `lines' `file' `searchstring'
  367.  *
  368.  *  where `lines' can be a string instead ... like a read-until, otherwise
  369.  *  the number of lines to read from the reference.
  370.  */
  371.  
  372. searchref(file, find, psstr, pfile, plines, pestr)
  373. char *file, *find;
  374. char **psstr, **pfile, **pestr;
  375. long *plines;
  376. {
  377.     long xfi;
  378.     char buf[256];
  379.     char *ptr, *base;
  380.     char *b1, *b2, *b3, *b4;
  381.     char quoted;
  382.     register int  findlen = strlen(find);
  383.  
  384.     if(!findlen)
  385.       return(0);
  386.     proc->pr_WindowPtr = (APTR)Ep->Win;
  387.     if (xfi = xfopen(file, "r", 4096)) {
  388.         while (xefgets(xfi,(base=buf), 256) >= 0) {
  389.             if (buf[0]=='#')
  390.                 continue;
  391.             ptr = breakout(&base, "ed, &b1);
  392.             if (ptr && *ptr && ref_cmp(ptr, find) == 0) {
  393.                 if (ptr = breakout(&base, "ed, &b2)) {
  394.                     *pestr = NULL;
  395.                     *plines = atoi(ptr);
  396.                     if (*plines == 0) {
  397.                         *pestr = (char *)malloc(strlen(ptr)+1);
  398.                         strcpy(*pestr, ptr);
  399.                     }
  400.                     if (ptr = breakout(&base, "ed, &b3)) {
  401.                         *pfile = (char *)malloc(strlen(ptr)+1);
  402.                         strcpy(*pfile, ptr);
  403.                         if (ptr = breakout(&base, "ed, &b4)) {
  404.                             *psstr = (char *)malloc(strlen(ptr)+1);
  405.                             strcpy(*psstr, ptr);
  406.                             xfclose(xfi);
  407.                             if (b1) free(b1);
  408.                             if (b2) free(b2);
  409.                             if (b3) free(b3);
  410.                             if (b4) free(b4);
  411.                             return(1);
  412.                         }
  413.                         free(*pfile);
  414.                         if (b4)
  415.                             free(b4);
  416.                     }
  417.                     if (pestr)
  418.                         free (*pestr);
  419.                     if (b3)
  420.                         free (b3);
  421.                 }
  422.                 if (b2)
  423.                     free(b2);
  424.             }
  425.             if (b1)
  426.                 free(b1);
  427.         }
  428.         xfclose(xfi);
  429.     }
  430.     return(0);
  431. }
  432.  
  433. #endif
  434.  
  435. #ifndef NO_DO_CTAGS
  436.  
  437. dirpart(str)
  438. register char *str;
  439. {
  440.     register short i;
  441.  
  442.     for (i = strlen(str) - 1; i >= 0; --i) {
  443.         if (str[i] == '/' || str[i] == ':')
  444.             break;
  445.     }
  446.     return(i+1);
  447. }
  448.  
  449. #endif
  450.  
  451.